package org.liuwei.concucrent.base04;

import java.io.IOException;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 
 * @Title: TestnewFixedThreadPool.java
 * @Package org.liuwei.concucrent.base04
 * @Description: TODO(固定大小线程池测试)
 * @author 刘伟 15818570028@163.com
 * @date 2016年8月21日 下午9:26:41
 * @version V1.0
 */
public class TestnewFixedThreadPool02 {

	public static void main(String[] args) throws IOException,
			InterruptedException {
		test();
		
//		new TestnewFixedThreadPool02().test2();
	}

	/**
	 * 
	 * @Title: test
	 * @Description: 从实例可以看到for循环并没有被固定的线程池阻塞住，
	 *               也就是说所有的线程task都被提交到了ExecutorService中， 查看
	 *               Executors.newFixedThreadPool()
	 * @param 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	private static void test() {
		ExecutorService service = Executors.newFixedThreadPool(2);
		for (int i = 0; i < 10; i++) {
			final int index = i;
			System.out.println("task: " + (i + 1));
			Runnable run = new Runnable() {
				public void run() {
					System.out.println("thread start" + index);
					try {
						Thread.sleep(Long.MAX_VALUE);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("thread end" + index);
				}
			};
			service.execute(run);
		}
		/*
		 * public static ExecutorService newFixedThreadPool(int nThreads) {
		 * return new ThreadPoolExecutor(nThreads, nThreads, 0L,
		 * TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>()); }
		 * 可以看到task被提交都了LinkedBlockingQueue中。 这里有个问题，如果任务列表很大，一定会把内存撑爆，
		 * 如何解决？看下面：
		 */
	}

	/**
	 * 
	 * @Title: test2
	 * @Description: TODO(如何解决？看下面：)
	 * @param 设定文件
	 * @return void 返回类型
	 * @throws
	 */
	public void test2() {

		BlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(3);

		ThreadPoolExecutor executor = new ThreadPoolExecutor( 3, 3, 1,
				TimeUnit.HOURS, queue,
				new ThreadPoolExecutor.CallerRunsPolicy());

		for (int i = 0; i < 10; i++) {
			final int index = i;
			System.out.println("task: " + (index + 1));
			Runnable run = new Runnable() {
				public void run() {
					System.out.println("thread start" + (index + 1));
					try {
						Thread.sleep(Long.MAX_VALUE);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("thread end" + (index + 1));
				}
			};
			executor.execute(run);
		}

		/*
		 * 线程池最大值为4（？？这里我不明白为什么是设置值+1，即3+1，而不是3），
		 * 准备执行的任务队列为3。可以看到for循环先处理4个task， 然后把3个放到队列。
		 * 这样就实现了自动阻塞队列的效果。记得要使用ArrayBlockingQueue这个队列，然后设置容量就OK了
		 */
	}
}